{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c73d25c2",
   "metadata": {},
   "source": [
    "# 基于DDDQN优化双量子门CZ门"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cc90fccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.linalg as lg\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.optimize import *\n",
    "\n",
    "import random\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import collections\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f96322d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PhaseCorrector:\n",
    "    def __init__(self, current_gate, target_gate ):\n",
    "        self.current_gate = current_gate\n",
    "        self.target_gate = target_gate\n",
    "        self.dimension = np.shape(self.current_gate)[0]\n",
    "        self.corrector_gate = np.mat(np.identity(self.dimension), dtype=complex)\n",
    "        \n",
    "    def calculate(self):\n",
    "        x_initial = np.random.uniform(size = [1, 2], low = - np.pi * 2, high = np.pi * 2)\n",
    "#         x_initial = np.random.uniform(size = [1, 2], low = - np.pi * 2, high = np.pi * 2)\n",
    "        #NM算法搜索时最好不要约束φ1和φ2的范围,不然有可能收敛到边界点,根本不是最优点\n",
    "        res = minimize(self.cost_function, x_initial, method = 'nelder-mead')\n",
    "\n",
    "        fidelity = 1 - res['fun']\n",
    "        return fidelity\n",
    "        \n",
    "    def cost_function(self, x):\n",
    "        self.corrector(x)\n",
    "        corrected_gate = self.corrector_gate * self.current_gate\n",
    "        \n",
    "        projection = self.target_gate.H * corrected_gate\n",
    "        trace = np.array(projection.trace()).flatten()[0] \n",
    "        fidelity = ((trace/self.dimension).real)**2 + ((trace/self.dimension).imag)**2\n",
    "        \n",
    "        cost = 1 - fidelity\n",
    "        return cost\n",
    "    \n",
    "    def corrector(self, x):\n",
    "        R_1 = np.mat([[1, 0],[0, np.exp(1j * x[0])]], dtype=complex)\n",
    "        R_2 = np.mat([[1, 0],[0, np.exp(1j * x[1])]], dtype=complex)\n",
    "        self.corrector_gate = np.kron(R_1, R_2)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "013eda2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class quantum_gate:\n",
    "    def __init__(self,  \n",
    "                 gate_time = 60, \n",
    "                 dt = 3, \n",
    "                 target_gate = np.mat([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]], dtype = complex),\n",
    "                 evaluate_mode = False):\n",
    "        self.evaluate_mode = evaluate_mode\n",
    "        self.dimension = 6\n",
    "        self.gate = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.history_gate = np.mat(np.identity(self.dimension), dtype = complex) #记录上一步的状态\n",
    "        self.history_gate_2 = np.mat(np.identity(self.dimension), dtype = complex) #记录上上步的状态\n",
    "        self.target_gate = target_gate #默认目标是实现CZ门\n",
    "        self.nstep = 0\n",
    "        self.gate_time = gate_time\n",
    "        self.dt = dt\n",
    "        self.sx = np.mat([[0, 1], [1, 0]], dtype = complex)\n",
    "        self.sz = np.mat([[1, 0], [0, -1]], dtype = complex)\n",
    "        self.sy = np.mat([[0, -1j], [1j, 0]], dtype = complex)\n",
    "        g = 0.012 * 2 * np.pi\n",
    "        g_2 = np.sqrt(2) * g\n",
    "        eta = -0.25 * 2 * np.pi\n",
    "        self.H_0 = np.mat([[0, 0, 0, 0, 0, 0], \n",
    "                           [0, 0, g, 0, 0, 0],\n",
    "                           [0, g, 0, 0, 0, 0],\n",
    "                           [0, 0, 0, 0, g_2, g_2],\n",
    "                           [0, 0, 0, g_2, eta, 0],\n",
    "                           [0, 0, 0, g_2, 0, eta]], dtype=complex)\n",
    "        self.H_d = np.mat([[0, 0, 0, 0, 0, 0],\n",
    "                           [0, 0, 0, 0, 0, 0],\n",
    "                           [0, 0, 1, 0, 0, 0],\n",
    "                           [0, 0, 0, 1, 0, 0],\n",
    "                           [0, 0, 0, 0, 0, 0],\n",
    "                           [0, 0, 0, 0, 0, 2]], dtype=complex)\n",
    "        self.strength_low = -0.35 * np.pi * 2\n",
    "        self.strength_high = 0.0 * np.pi * 2\n",
    "        self.name = \"optimal two qubit quantum gate\"\n",
    "        self.done = 0\n",
    "        self.fidelity = [0]\n",
    "        \n",
    "        self.observe_state()\n",
    "    \n",
    "    def observe_state(self):#因为神经网络不能识别复数矩阵，所以要把实部虚部分开，并展成一维数组，喂给神经网络   \n",
    "\n",
    "        self.state = []\n",
    "\n",
    "        #加入历史信息，传给神经网络\n",
    "        temp = np.array(self.history_gate_2[0:4,0:4]).flatten()\n",
    "        for item in temp:\n",
    "            self.state.append(item.real)\n",
    "            self.state.append(item.imag)\n",
    "\n",
    "        temp = np.array(self.history_gate[0:4,0:4]).flatten()\n",
    "        for item in temp:\n",
    "            self.state.append(item.real)\n",
    "            self.state.append(item.imag)\n",
    "\n",
    "        temp = np.array(self.gate[0:4,0:4]).flatten()\n",
    "        for item in temp:\n",
    "            self.state.append(item.real)\n",
    "            self.state.append(item.imag)\n",
    "\n",
    "        self.state.append(self.nstep)\n",
    "        self.state = np.array(self.state)\n",
    "        \n",
    "        return\n",
    "    \n",
    "    def reset(self):\n",
    "        self.gate = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.history_gate = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.history_gate_2 = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.observe_state()\n",
    "        self.nstep = 0\n",
    "        self.done = 0\n",
    "        self.fidelity = [0]\n",
    "        return self.state\n",
    "    \n",
    "    def Hamiltonian(self, strength):\n",
    "        H = strength * self.H_d + self.H_0\n",
    "        return H\n",
    "    \n",
    "    def reward(self):\n",
    "        current_gate = self.gate[0:4,0:4]\n",
    "        target_gate = self.target_gate[0:4,0:4]\n",
    "        if self.done ==1:\n",
    "            phase_corrector = PhaseCorrector(current_gate, target_gate)\n",
    "            fidelity = phase_corrector.calculate()\n",
    "            for i in range(3):\n",
    "                fidelity = max(fidelity, phase_corrector.calculate())\n",
    "        elif self.evaluate_mode == True:\n",
    "            phase_corrector = PhaseCorrector(current_gate, target_gate)\n",
    "            fidelity = phase_corrector.calculate()\n",
    "            \n",
    "\n",
    "            for i in range(15):\n",
    "                fidelity = max(fidelity, phase_corrector.calculate())\n",
    "\n",
    "        else:\n",
    "            fidelity = 0\n",
    "            \n",
    "        err = 1 - fidelity\n",
    "\n",
    "        reward = -np.log(err) if self.done == 1 else 0\n",
    "        \n",
    "\n",
    "        \n",
    "        self.fidelity.append(fidelity)\n",
    "        return [reward, fidelity]\n",
    "    \n",
    "    def step(self, strength):\n",
    "        self.history_gate_2 = self.history_gate\n",
    "        self.history_gate = self.gate\n",
    "        U = lg.expm(-1j * self.Hamiltonian(strength) * self.dt)\n",
    "        U = np.mat(U)\n",
    "        self.gate = U * self.gate\n",
    "        self.observe_state()\n",
    "        \n",
    "        self.nstep += 1\n",
    "        self.done = self.nstep * self.dt >= self.gate_time\n",
    "        reward, fidelity = self.reward()\n",
    "#         if fidelity > 0.999:\n",
    "#             self.done = 1\n",
    "        \n",
    "        return [self.state, reward, self.done, fidelity, self.gate]\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "66b1eca5",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    ''' 经验回放池 '''\n",
    "    def __init__(self, capacity):\n",
    "        self.buffer = collections.deque(maxlen=capacity) # 队列，先进先出\n",
    "\n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        self.buffer.append((state, action, reward, next_state, done)) # 将数据加入buffer\n",
    "\n",
    "    def sample(self, batch_size): # 从buffer中采样数据，数量为batch_size\n",
    "        transitions = random.sample(self.buffer, batch_size)\n",
    "        state, action, reward, next_state, done = zip(*transitions)\n",
    "        return np.array(state), action, reward, np.array(next_state), done\n",
    "\n",
    "    def size(self): # 目前buffer中数据的数量\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "37115b2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SumTree(object):\n",
    "    #我尝试过把PER加入算法中，不过毕设时间仓促，没有调出来\n",
    "    \"\"\"\n",
    "    This SumTree code is a modified version and the original code is from:\n",
    "    https://github.com/jaara/AI-blog/blob/master/SumTree.py\n",
    "    Story data with its priority in the tree.\n",
    "    \"\"\"\n",
    "    data_pointer = 0\n",
    "\n",
    "    def __init__(self, capacity):\n",
    "        self.capacity = capacity  # for all priority values\n",
    "        self.tree = np.zeros(2 * capacity - 1)\n",
    "        # [--------------Parent nodes-------------][-------leaves to recode priority-------]\n",
    "        #             size: capacity - 1                       size: capacity\n",
    "        self.data = np.zeros(capacity, dtype=object)  # for all transitions\n",
    "        # [--------------data frame-------------]\n",
    "        #             size: capacity\n",
    "\n",
    "    def add(self, p, data):\n",
    "        tree_idx = self.data_pointer + self.capacity - 1\n",
    "        self.data[self.data_pointer] = data  # update data_frame\n",
    "        self.update(tree_idx, p)  # update tree_frame\n",
    "\n",
    "        self.data_pointer += 1\n",
    "        if self.data_pointer >= self.capacity:  # replace when exceed the capacity\n",
    "            self.data_pointer = 0\n",
    "\n",
    "    def update(self, tree_idx, p):\n",
    "        change = p - self.tree[tree_idx]\n",
    "        self.tree[tree_idx] = p\n",
    "        # then propagate the change through tree\n",
    "        while tree_idx != 0:    # this method is faster than the recursive loop in the reference code\n",
    "            tree_idx = (tree_idx - 1) // 2\n",
    "            self.tree[tree_idx] += change\n",
    "\n",
    "    def get_leaf(self, v):\n",
    "        \"\"\"\n",
    "        Tree structure and array storage:\n",
    "        Tree index:\n",
    "             0         -> storing priority sum\n",
    "            / \\\n",
    "          1     2\n",
    "         / \\   / \\\n",
    "        3   4 5   6    -> storing priority for transitions\n",
    "        Array type for storing:\n",
    "        [0,1,2,3,4,5,6]\n",
    "        \"\"\"\n",
    "        parent_idx = 0\n",
    "        while True:     # the while loop is faster than the method in the reference code\n",
    "            cl_idx = 2 * parent_idx + 1         # this leaf's left and right kids\n",
    "            cr_idx = cl_idx + 1\n",
    "            if cl_idx >= len(self.tree):        # reach bottom, end search\n",
    "                leaf_idx = parent_idx\n",
    "                break\n",
    "            else:       # downward search, always search for a higher priority node\n",
    "                if v <= self.tree[cl_idx]:\n",
    "                    parent_idx = cl_idx\n",
    "                else:\n",
    "                    v -= self.tree[cl_idx]\n",
    "                    parent_idx = cr_idx\n",
    "\n",
    "        data_idx = leaf_idx - self.capacity + 1\n",
    "        return leaf_idx, self.tree[leaf_idx], self.data[data_idx]\n",
    "    \n",
    "    @property\n",
    "    def total_p(self):\n",
    "        return self.tree[0]  # the root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4f526f63",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Memory(object):  # stored as ( s, a, r, s_ ) in SumTree\n",
    "    #我尝试过把PER加入算法中，不过毕设时间仓促，没有调出来\n",
    "    \"\"\"\n",
    "    This Memory class is modified based on the original code from:\n",
    "    https://github.com/jaara/AI-blog/blob/master/Seaquest-DDQN-PER.py\n",
    "    \"\"\"\n",
    "    epsilon = 0.01  # small amount to avoid zero priority\n",
    "    alpha = 0.6  # [0~1] convert the importance of TD error to priority\n",
    "    beta = 0.4  # importance-sampling, from initial value increasing to 1\n",
    "    beta_increment_per_sampling = 0.001\n",
    "    abs_err_upper = 1.  # clipped abs error\n",
    "\n",
    "    def __init__(self, capacity):\n",
    "        self.tree = SumTree(capacity)\n",
    "\n",
    "    def store(self, transition):\n",
    "        #找出这个数组倒数capacity个数中的最大值，实际上就是找出sum tree的叶子节点的最大值\n",
    "        max_p = np.max(self.tree.tree[-self.tree.capacity:]) \n",
    "        if max_p == 0:\n",
    "            max_p = self.abs_err_upper\n",
    "        self.tree.add(max_p, transition)   # set the max p for new p\n",
    "\n",
    "    def sample(self, n):\n",
    "        b_idx, b_memory, ISWeights = np.empty((n,), dtype=np.int32), np.empty((n, self.tree.data[0].size)), np.empty((n, 1))\n",
    "        pri_seg = self.tree.total_p / n       # priority segment\n",
    "        self.beta = np.min([1., self.beta + self.beta_increment_per_sampling])  # max = 1\n",
    "\n",
    "        min_prob = np.min(self.tree.tree[-self.tree.capacity:]) / self.tree.total_p     # for later calculate ISweight\n",
    "        for i in range(n):\n",
    "            a, b = pri_seg * i, pri_seg * (i + 1)\n",
    "            v = np.random.uniform(a, b)\n",
    "            idx, p, data = self.tree.get_leaf(v)\n",
    "            prob = p / self.tree.total_p\n",
    "            ISWeights[i, 0] = np.power(prob/min_prob, -self.beta)\n",
    "            b_idx[i], b_memory[i, :] = idx, data\n",
    "        return b_idx, b_memory, ISWeights\n",
    "\n",
    "    def batch_update(self, tree_idx, abs_errors):\n",
    "        abs_errors += self.epsilon  # convert to abs and avoid 0\n",
    "        clipped_errors = np.minimum(abs_errors, self.abs_err_upper)\n",
    "        ps = np.power(clipped_errors, self.alpha)\n",
    "        for ti, p in zip(tree_idx, ps):\n",
    "            self.tree.update(ti, p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "69d2b4c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Qnet(torch.nn.Module):\n",
    "    ''' 一层隐层的Q网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(Qnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, 600)\n",
    "#         self.fc2 = torch.nn.Linear(600, 600)\n",
    "        self.fc2 = torch.nn.Linear(600, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "#         x = F.relu(self.fc2(x))\n",
    "        x = self.fc2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "182ea71c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class VAnet(torch.nn.Module):\n",
    "    ''' 一层隐层的A网络和V网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(VAnet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, 1200) # 共享网络部分\n",
    "        \n",
    "        self.fc_A = torch.nn.Linear(1200, action_dim)\n",
    "        self.fc_V = torch.nn.Linear(1200, 1)\n",
    "\n",
    "    def forward(self, x):\n",
    "        A = self.fc_A(F.relu(self.fc1(x)))\n",
    "        V = self.fc_V(F.relu(self.fc1(x)))\n",
    "        Q = V + A - A.mean(1).view(-1, 1) # Q值由V值和A值计算得到\n",
    "        return Q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "31f707cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQN:\n",
    "    ''' DQN算法，包括Double DQN和Dueling DQN '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma, epsilon, target_update, device, dqn_type='VanillaDQN'):\n",
    "        self.action_dim = action_dim\n",
    "        if dqn_type == 'DuelingDQN': # Dueling DQN采取不一样的网络框架\n",
    "            self.q_net = VAnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "            self.target_q_net = VAnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "#             self.ans_q_net = VAnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "        else:\n",
    "            self.q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "            self.target_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "#             self.ans_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "\n",
    "\n",
    "#         self.best_fidelity = 0\n",
    "        self.optimizer = torch.optim.Adam(self.q_net.parameters(), lr=learning_rate)\n",
    "#       ***********************************************************************************\n",
    "#         gamma = 1-1e-4\n",
    "        gamma = 1\n",
    "#       ***********************************************************************************\n",
    "        self.my_rl_scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer = self.optimizer, gamma = gamma) \n",
    "        self.gamma = gamma\n",
    "        self.epsilon = epsilon\n",
    "        self.target_update = target_update\n",
    "        self.count = 0\n",
    "        self.dqn_type = dqn_type\n",
    "\n",
    "    def take_action(self, state):\n",
    "        if np.random.random() < self.epsilon:\n",
    "            action = np.random.randint(self.action_dim)\n",
    "        else:\n",
    "            state = torch.tensor(np.array([state]), dtype=torch.float).to(device)\n",
    "            action = self.q_net(state).argmax().item()\n",
    "        return action\n",
    "    \n",
    "    def final_policy_action(self, state):\n",
    "        state = torch.tensor(np.array([state]), dtype=torch.float).to(device)\n",
    "        action = self.q_net(state).argmax().item()\n",
    "        return action\n",
    "\n",
    "    def max_q_value(self, state):\n",
    "        state = torch.tensor(np.array([state]), dtype=torch.float).to(device)\n",
    "        return self.q_net(state).max().item()\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(device)\n",
    "        actions =  torch.tensor(transition_dict['actions']).view(-1, 1).to(device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(device)\n",
    "\n",
    "        q_values = self.q_net(states).gather(1, actions)\n",
    "        if self.dqn_type == 'DoubleDQN' or self.dqn_type == 'DuelingDQN':\n",
    "            max_action = self.q_net(next_states).max(1)[1].view(-1, 1)\n",
    "            max_next_q_values = self.target_q_net(next_states).gather(1, max_action)\n",
    "        else:\n",
    "            max_next_q_values = self.target_q_net(next_states).max(1)[0].view(-1, 1)\n",
    "        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)\n",
    "        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))\n",
    "        self.optimizer.zero_grad()\n",
    "        dqn_loss.backward()\n",
    "        self.optimizer.step()\n",
    "        agent.my_rl_scheduler.step()\n",
    "\n",
    "        if self.count % self.target_update == 0:\n",
    "            self.target_q_net.load_state_dict(self.q_net.state_dict())\n",
    "        self.count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7de8bc15",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dis_to_con(discrete_action, env, action_dim): # 离散动作转回连续的函数\n",
    "    action_lowbound = env.strength_low # 连续动作的最小值\n",
    "    action_upbound = env.strength_high # 连续动作的最大值\n",
    "    return action_lowbound + (discrete_action / (action_dim - 1)) * (action_upbound - action_lowbound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f46d2f67",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_DQN(agent, env, num_episodes, replay_buffer_size , minimal_size, batch_size, prioritized = False):\n",
    "    return_list = []\n",
    "    fidelity_list = []\n",
    "    max_q_value_list = []\n",
    "    fid_his = []\n",
    "    fid_test = []\n",
    "    max_q_value = 0\n",
    "    \n",
    "#     evaluate_num = 20\n",
    "    evaluate_num = 1\n",
    "    evaluate_fidelity = []\n",
    "    evaluate_average_fidelity = []\n",
    "    \n",
    "    if prioritized == False:\n",
    "        replay_buffer = ReplayBuffer(buffer_size)\n",
    "    else:\n",
    "        replay_buffer = Memory(buffer_size)\n",
    "    \n",
    "    for i in range(10):\n",
    "        with tqdm(total=int(num_episodes/10), desc='Iteration %d' % i) as pbar:\n",
    "            for i_episode in range(int(num_episodes/10)):\n",
    "                episode_return = 0\n",
    "                state = env.reset()\n",
    "                done = False\n",
    "                while not done:\n",
    "                    action = agent.take_action(state)\n",
    "                    max_q_value = agent.max_q_value(state) * 0.005 + max_q_value * 0.995 # 平滑处理\n",
    "                    max_q_value_list.append(max_q_value) # 保存每个状态的最大Q值\n",
    "                    action_continuous = dis_to_con(action, env, agent.action_dim)\n",
    "                    next_state, reward, done, fidelity, _ = env.step(action_continuous)\n",
    "                    \n",
    "#                     if fidelity > agent.best_fidelity:#记录最好的训练结果\n",
    "#                         agent.best_fidelity = fidelity\n",
    "#                         agent.ans_q_net.load_state_dict(agent.q_net.state_dict())\n",
    "                    \n",
    "                    if prioritized == False:\n",
    "                        replay_buffer.add(state, action, reward, next_state, done)\n",
    "                    else:\n",
    "                        replay_buffer.store([state, action, reward, next_state, done])\n",
    "                        \n",
    "                    \n",
    "#                     for i in range(test_at_ecah_step):\n",
    "#                         fid_test[episode * test_at_ecah_step + i][0] = episode\n",
    "#                         fid_test[episode * test_at_ecah_step + i][1] = test_maze()\n",
    "        \n",
    "#                     fid_his.append(fid_test[episode * test_at_ecah_step : (episode + 1) * test_at_ecah_step, 1].mean())\n",
    "                    \n",
    "                    state = next_state\n",
    "                    episode_return += reward\n",
    "                    if replay_buffer.size() > minimal_size:\n",
    "                        b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(max(batch_size, int(0.1 * replay_buffer.size())))\n",
    "                        transition_dict = {'states': b_s, 'actions': b_a, 'next_states': b_ns, 'rewards': b_r, 'dones': b_d}\n",
    "                        agent.update(transition_dict)\n",
    "                return_list.append(episode_return)\n",
    "                fidelity_list.append(fidelity)\n",
    "                \n",
    "                #使用平均fidelity评估当前策略\n",
    "                temp = 0\n",
    "                for j in range(evaluate_num):\n",
    "                    evaluate_DQN(agent, env)\n",
    "                    temp += env.fidelity[-1]\n",
    "                    evaluate_fidelity.append([i * num_episodes/10 + i_episode, env.fidelity[-1]])\n",
    "                evaluate_average_fidelity.append(temp / evaluate_num)\n",
    "                \n",
    "#                 if i >=2:\n",
    "#                     agent.my_rl_scheduler.step() #训练了一段时间后，要适当降低学习率\n",
    "                \n",
    "                if (i_episode+1) % 10 == 0:\n",
    "                    pbar.set_postfix({'episode': '%d' % (num_episodes/10 * i + i_episode+1), 'return': '%.3f' % np.mean(return_list[-10:])})\n",
    "                pbar.update(1)\n",
    "    return return_list, max_q_value_list, fidelity_list, evaluate_fidelity, evaluate_average_fidelity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2ccecac9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_DQN(agent, env):\n",
    "\n",
    "    state = env.reset()\n",
    "    action_list = []\n",
    "    debug_list = []\n",
    "    done = False\n",
    "    while not done:\n",
    "        action = agent.final_policy_action(state)\n",
    "        debug_list.append(action)\n",
    "        action_continuous = dis_to_con(action, env, agent.action_dim)\n",
    "        action_list.append(action_continuous)\n",
    "        next_state, reward, done, fidelity, _ = env.step(action_continuous)\n",
    "        state = next_state\n",
    "        \n",
    "    return action_list, debug_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "8d2bd74e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_sequence(x, dt=3):\n",
    "#     action_num = 13\n",
    "    \n",
    "    env = quantum_gate(dt=dt/100, evaluate_mode = True)#这里为了画的精细一点，专门把dt从默认的2变成了0.03\n",
    "    \n",
    "    data_his = []\n",
    "    data_his.append(env.gate)\n",
    "    fid_his = []\n",
    "    fid_his.append(env.reward()[1])\n",
    "    \n",
    "    \n",
    "    for i in range(len(x)):\n",
    "        for j in range(100):\n",
    "            strength = x[i]\n",
    "            _, reward, done, fidelity, gate = env.step(strength)\n",
    "            data_his.append(gate)\n",
    "            fid_his.append(fidelity)\n",
    "    \n",
    "    plt.figure(figsize = (14, 12))\n",
    "    plt.plot(np.arange(len(fid_his)) * env.dt,fid_his)  \n",
    "    plt.xlabel('Time')\n",
    "    plt.ylabel('Real time fidelity')\n",
    "    plt.title('DDDQN on two-qubit gate')\n",
    "    \n",
    "    print(\"fidelity = \", fid_his[-1])\n",
    "    \n",
    "    temp = env.gate[0,0]\n",
    "    phase = np.exp(-1j*np.angle(temp))\n",
    "#     phase = np.sqrt(np.linalg.det(env.gate))\n",
    "    print(env.gate * phase)\n",
    "    \n",
    "    return fidelity"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01e01cc5",
   "metadata": {},
   "source": [
    "# 使用DDDQN优化CZ门"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "88fa5446",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|████████████████████████████████████████| 600/600 [02:28<00:00,  4.03it/s, episode=600, return=2.077]\n",
      "Iteration 1: 100%|███████████████████████████████████████| 600/600 [03:12<00:00,  3.12it/s, episode=1200, return=3.648]\n",
      "Iteration 2: 100%|███████████████████████████████████████| 600/600 [03:21<00:00,  2.98it/s, episode=1800, return=3.479]\n",
      "Iteration 3: 100%|███████████████████████████████████████| 600/600 [03:32<00:00,  2.83it/s, episode=2400, return=4.865]\n",
      "Iteration 4: 100%|███████████████████████████████████████| 600/600 [03:45<00:00,  2.66it/s, episode=3000, return=5.330]\n",
      "Iteration 5: 100%|███████████████████████████████████████| 600/600 [03:45<00:00,  2.66it/s, episode=3600, return=4.325]\n",
      "Iteration 6: 100%|███████████████████████████████████████| 600/600 [03:33<00:00,  2.81it/s, episode=4200, return=5.195]\n",
      "Iteration 7: 100%|███████████████████████████████████████| 600/600 [03:32<00:00,  2.83it/s, episode=4800, return=4.717]\n",
      "Iteration 8: 100%|███████████████████████████████████████| 600/600 [03:40<00:00,  2.72it/s, episode=5400, return=4.609]\n",
      "Iteration 9: 100%|███████████████████████████████████████| 600/600 [03:18<00:00,  3.02it/s, episode=6000, return=5.684]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "last epoch fidelity =  0.9973082624109362\n",
      "final agent output fidelity =  0.9973082623853018\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABCE0lEQVR4nO2dd5wV1fXAv2cr7NJZOiwLgiBIkQ72LiL2XmM0hNgTY4KJscTE8kti1KhBkliSGE2MNQY1aqImVkBFwYqKilhQadJ39/z+mFl4+/aVeW9n3rx573w/n7c75c6dc9+buefec+89R1QVwzAMo3gpCVsAwzAMI1xMERiGYRQ5pggMwzCKHFMEhmEYRY4pAsMwjCLHFIFhGEaRY4rAMAoIEblURP6c4vxiEdkjdxIZUcAUgZEQEVkqIhtEZK2IrBKRZ0VkpoiUxKS5TUQ2u2nWisgiEblSRDrGpPmGiDSIyNfu530RuVVEto+7X6V77Yfufd8Rke+LiMSkeVJENopIv5hj+4jI0oC/DkRkDxFZFvR9gkZVh6vqk5BeabQW9/c6Paj8Df8wRWCkYrqqtgf6A1cBPwT+EJfm/9w03YBTgUnAMyJSHZPmOVVtB3QE9gE2AAtEZMeYNHcDewMHAu2Bk4BvA7+Ku9864Cc+lM0wDBdTBEZaVHW1qj4IHAOcEleBN6XZqKrzgIOBrjhKIT5Ng6q+q6pnAE8BlwKIyN7AfsARqrpIVetV9XngROBcERkYk831wHEiMsiL7CIyRUTmichq9/+UmHNPisjlIvKM26P5l4jUJMijGngY6B3Ts+nt9lxq3DQXiUi9iHRw938mIte62x1F5I8iskJEPnDTJn33RGSAiDzlyvSYiNzQ1HJP1DNxe2/7xBxqIyJ/da9/SURGxacVkQOAHwHHuOVZmESWMSLyspvX3W6+P3PPdRaRh9xyrXS3+7rnfg7sCtzg5n+De3yoW6avROQtETk62fdg5A5TBIZnVPVFYBnOC54szVrgsVRpXO6NSbMv8IKqfhSX1wvu/faOOfwx8DtcJZIKEekC/BNHeXQFrgH+KSJdY5Idj6O0ugMVwPcTlGkdMBVYrqrt3M9yYB6wu5tsN+ADYOeY/afc7d/g9IYGuulPJoGijOEvwAKgBrgcOCVdWeM4BKeH1cXN634RKY8r0yPAFcBf3fKMis9ERCqA+4Db3LzuBA6LSVIC3IrTY6zF6end4Ob/Y+C/wFlu/me5CvUxV6buwHHATSIyPMPyGT5jisDIlOU4lYKfaWqAT5Kk+wTH7BTLlcB0DxXINOAdVf2T28u4E3gTmB6T5lZVfVtVNwB/A0anyTOWp4DdRaQMGImjcHYXkTbAeOC/IlKK05O6UFXXqupSHHPXSYkyFJFa99qfqOomVX0a+EcGMgEsUNW/q+oWHOXXBsdklymTgDLgelXdoqr3Ai82nVTVL1X1HlVd7zYAfs42xZiIg4Clqnqr+3u8BNwDHJmFbIaPmCIwMqUP8JXPab4AeiVJ1wtYEXtAVVfgtDx/muYevXFa6bF84N67iU9jttcD7dLkGctTwB7AGOA1nNbu7jgV6BJV/QJHyVXEybFVBhGZHWNu+pEr80q3FxKbPhO29qxUtRGnV9U7wzxwr/lYm3um3Jq3iFSJyM2uuWsN8DTQyVV+iegPTBRn8sEqEVkFnAD0zEI2w0dMERieEZHxOBXY/1KkaYczIPzfNNkdFpPmcZwKol9sAhGZgGNyeDrB9b8A9gTGprjHcpzKJ5ZaHPNSpiRy0/ssMASnLE+p6utu/tPYZhb6AtgSJ8dWGVR1Zoy56QqcHlDnuMH22pjtdUBV045b6cb3mGJnVZUAfXG+Cy9liuUToE/szK3YvIHzcco/UVU74JjDAJrSx+f/Ec731Cnm005Vv5NGDiNgTBEYaRGRDiJyEHAX8GdVfS1BmkoRGQvcD6zEsR3Hpyl1B0J/g9OSvgxAVR8HngDuEZHhbrpJwB3AH1X1rfi8VHUVjonlBylEnwtsLyLHi0iZiBwDDAMe8l76rXwGdJWYqbGquh7Hln8m2yr+Z3FmOz3lpmnAMTn9XETai0h/4HtAwmmbqvoBMB+4TEQqRGQXmpuy3sYZDJ7m2v0vAirjshkrIoe7JqvzgE3A80nKVJdi4Po5oAE4y/3+DgEmxJxvjzMusModj7kkQf6xA/0P4fweJ4lIufsZLyI7JLm/kSNMERip+IeIrMVpyf0Yx94cP8j5AzfNV8AfcSrGKXGmjcki8jWwBngS6ACMj1MoRwD/AR4BNuJUQo8AM1LIdx1ORZUQVf0Sxy59PvAljtI4yDXZZISqvokzWPqea9ZoMrU8BZSzzXb+FE4FGduLORunJf8eTm/qL8AtKW53PDAR5zu9BOd7bZJjNXAG8HucXsU6HNNPLA/gjEusxBmLONwdL4jnbvf/lyLyUoIybwYOB04DVuHM4noIR7EAXAu0xen1PI/ze8VyHXCkO6PoenccYT/gWJweyqfA1bRUZEaOEQtMY+QjInI7jhnqQLdCKlpE5FJgkKqemAeyvADMVtUWPT4juliPwMhXTscZfB0TtiDFjIjsLiI9XdPQKTizo+Jb/kbEKQtbAMNIhGvKuDpsOQyG4IxxtAPeBY5U1WRTfY2IYqYhwzCMIsdMQ4ZhGEVO5ExDNTU1WldXF7YYhmEYkWLBggVfqGr8mhMggoqgrq6O+fPnhy2GYRhGpBCRpCvUzTRkGIZR5JgiMAzDKHJMERiGYRQ5pggMwzCKHFMEhmEYRU5gikBEbhGRz0VkUZLzIiLXi8gSEXlVRMyVgGEYRggE2SO4DTggxfmpwGD3MwP4bYCyGIZhGEkIbB2Bqj4tInUpkhyC42tegedFpJOI9DI/JtFDVWkeu6Q5i5evZlN9I2NqO6fNa+W6zXSqKmfd5gbKS4WNmxtBoLFRaVClXWUZX2+qp0QEVaVtRSlb6pVNDQ20LS+lsRFKSmBLgyJASYnQ2KhsrG+gxJWxKY/SEme/usJ5DTbXN9KmooTN9Y1s2Ox4ty4rLaGyrIT6RmVLQyMVZSVs2NxAeWkJ9Y2NoFBdWcbGLQ2UlZSgKI0KDY1KZXkJm7Y0UloilJYIDY1KiYCqI9em+gYqy5xgXvUNjZSIsLmhkY5ty9lU30hDo/L8e1/Sv2sV/bpUUVFawtqN9axYu4keHSppUKVUhPIy5z6KUllauu27UBCBdZvqqa4so7ykhFUbNtPGvacICM49SwQaFeobG3npg1XsNbQ7azY6nqurK8toaFDKSoXVG7ZQWiKUlQgVZSWICOWlwobNDWyqb6SyzGlbfvH1Jjq0KUdx7q9A1+oKSkuELQ3K4298xuSBXelSXcEnqzfSo0MlVRVlfPH1Jr5at5mu1RW0a1PGxi2NVFWUsmFzA20rStm0pdGRvQQaGhz3OFsaG6ksK0UEttQ3IiI0ut9NWalQ36DUNzrPSnmpsG5TA6UiKMqL739FuzZl9OrYlgUfrGSvod23/i5VFaUs+fxrPluzkSnb1dCoyvrNDVRXOs9ckxzg3LdEhBKRrc9a0ytRXlpCo/s83LNgGQeO6IXC1me4rLSE+oZGFOe5KS8tQYCyUqFRnfertMQpR2V5CVUV/lfbYS4o60NM2Dscn+p9SBC7VkRm4Pqlr62tjT9tAJvqGxhy0SOM6tuRSdt15cMv1/PbE5MH7/p8zUYmXPEE8y/ah5p2Ld3BL/jgK556awXf229Is+PvfLaWC/7+Kn8+fSLtKstY8vla9rnmaYb2bM9lBw/n60317L1DD+588UM6tS1n6oheTLveCWi29KppgPNg//O1T/jb/GUs/WIdH3613sdvwjDym588sDjra0+e3J+fHrKjj9I4hKkIEjUhE3rAU9U5wByAcePGmZe8BHy6eiMAC5etZuGy1WnTT7jiCQAO/s3/ePbCvVucP+K3zwFw9t6DKS/dZkG8+pG3eOWjVTy75Av2G96Tf7/5OQBvfrqWY+Y4QbCWXjWNC+91Ys50ripvkfffFyzjgr+/mknxDMMA6rpWp0+UBWHOGlpG8/inyeKqGlmypaGR9Zvrmx07+86XGX7xNnfym+obU+Yx+McPs6m+ZRCwVz5axUdfreeKuW+2OFc3659bt1eu3xYYa9X6zaxct5nFy9d4LoNhGNuYNLBrIPmG2SN4ECcW6l04YflWF9P4wOm3z6dNeQk3HO/PZKlE3sRP+N0LvLj0K96/8sCtNvx/LGyuaxW48N7XuPPFD7eabuLZsHmbLXvxcqe3cdOT73LTk+9mJOPonz6WUXrDMJrTNK7lN0FOH70TJ+7sEBFZJiKnichMEZnpJpmLE8N1CfA7nDisRcPjb3zGQ6/6p/fufPHDFsdeXPoVAH+d91GLc018tW5zwmtjqW90tMynqzfyiWuCMgwj9wSkBwKdNXRcmvMKnBnU/YuN+JZ+LLPufY1jJ6QfZL9i7htcOHUoH6/a0Ox4g6sIPlm9IdFlhmHkiFSz81qDrSzOA/743FI+X5tZS3vNxi0ccuMzPPful6yOscMn4+UPV/LY65+lTDPn6ffY0qDscvV/mh3f7I4j2Ci9YYRL5HoEhjeWfrGOix9YzAOvLOee70zxfN2jiz5l4UerOO53z9OhTRnt27ScnRPLYTc96ynfxgSDDb9+7G2uOWa0Z9kMwwiG2i5VgeRriiBktjQ4re1V6zdndN3/PfrW1u01G+tZs7E+RWrvDP3JIy2O3fvyx9z78se+5G8YRvaUlQZjxDHTUMg0tb8ztf2tWLvJf2EMwyhKTBGETJMrg4BMf4ZhGGkxRRAyV8x9A4B3Pv+aKVc+wYbNDSz5/Gve/2Jdi7SvfLSKz9du5I1PbEGWYRj+kXaMQETmA7cCf1HVlcGLVPi8+em2ivyF97/aur189UbeXfE1B/3G8c3zq6NGccTYvlvPH3rjM7kT0jCMosHLYPGxwKnAvBil8C93HYDhkbpZ/+Tbuw3kwgN3SDndc8Yf52/dPv/uhfz2qXdZ8vnXuRDRMIwiJa1pSFWXqOqPge2BvwC3AB+KyGUi0iVoAfOVh15dTt2sf/JRBp4zb376PSD1wPDyuJW7pgQMI3ocMrp32CJkhKcxAhEZCfwK+AVwD3AksAb4d3Ci5Tf3v+ys5E1lr//NE+9w9M3PNTvW2Kjc+sz7gcpmGEa4NMVliApexggWAKuAPwCzVLVp3uILIrJzgLLlOcktY79+7G1G9evIrx57u8W5uYs+4eFFnwYpmGHkLSdMrOWOF1L7tjJyj5cxgqNU9b1EJ1T1cJ/liRyJzDzXPfFOs/3Y4ZT1m1u6dDaMYqFLdUXYIhgJSKoIROR7MdstzqvqNQHJFAkyGSq3YXXDMPKZVD2C9u7/IcB4nPgBANOBp4MUKkp4WQgWqweaXEoYhmHkC0lHNFT1MlW9DKgBxqjq+ap6PjAWJ5pYUZOoka+qvPRhy6UWsY7cfnzfogClMgwj35mdIpZ4WHgZ2q4FYj2ibQbqApEmgsRazW749xIOT+Dl00xDhmE0ccCOPVl48X5hi9EML4rgT8CLInKpiFwCvAD80UvmInKAiLwlIktEZFaC851F5D4ReVVEXhSRHTMTP79IFulr+4sezrEkRrFw3bGjwxbBSEC7ytRu4TtWpT6fa7wsKPs5zsrilTjTSE9V1SvSXScipcCNwFRgGHCciAyLS/Yj4BVVHQmcDFyXkfQhYgurjWKlT6e2YYuQlF8fMypsEQD4/v7bp11UFlCwsazwuuqhClijqtcBy0RkgIdrJgBLVPU9Vd0M3AUcEpdmGPAEgKq+CdSJSA+PMuUF+fRjGkYu+PlhwXXcW7sid2BNu4yvKS/N/CU+YkzqYdKqijKuO3anlGmmjeiV8X2DIq0icM1BPwQudA+VA3/2kHcfIDZq+jL3WCwLgcPd+0wA+pNgIFpEZojIfBGZv2LFCg+3Dh7rD2TPFYeNCFsEoxUU2rN/0MjMlU+bcv9XDndvX+l7nl7xUprDgIOBdQCqupxtU0tTkUjNxj9DVwGdReQV4GzgZaBFqC1VnaOq41R1XLdu3TzcOndITDHj/QQZiTl+Yi23nTo+bDGMPKSYLa4d2oY3buBFEWx2PY0qgIhUe8x7GdAvZr8vsDw2gaquUdVTVXU0zhhBNyASjniWrdwQtgiRZo8h3cMWwchDwtADw3t3COGuLQnTyuxFEfxNRG4GOonIt4DHgd95uG4eMFhEBohIBY476wdjE4hIJ/ccwOnA06oaiagr5hXUMAqD03bxMuRZ2KT1NaSqvxSRfXG8jQ4BLlbVxzxcVy8iZwGPAqXALaq6WERmuudnAzsAfxSRBuB14LTsi2IYRk4IsNkexmy8TOOF+0U+WcG8OJ0DeBtQVX1cRKpEpL2qrk13karOBebGHZsds/0cMDgTgfMOmzVkACdN6s+fnv8g5/cNoxLTAKuwfKocc02YMxC9zBr6FvB34Gb3UB/g/gBlMozIUZZkCuLNJ43l0fN2o2/n1HPv9x8eqVnTRU+hTRv3MkZwJrAzjmkIVX0HsJE+lwJ7Hgyf2X94T4b0TD/J7tSdo2OnHtozPwZXCw0JsTbxogg2uQvCABCRMoq7B9eMsOyL+crIvh3DFiElbctLQ7lvoUyLvOboUfTu1JZbs5z+W9MuzVz5AvmekpGv74cXRfCUiPwIaOsOGt8N/CNYsYyoMrDG6+zicOjdqU3YIhQE2SrUEyf1Z8c+yXsUQY4/5B15VFQviuCHwArgNeDbOIO/FwUplBFd2lZsm39ww/Etl9gvvWpaLsXJeyYM6BK2CDmltEQ4dHS8g4HoEYQZJ28Hi0WkBHhNVX+nqkep6pHudh7pMiOfOGjkNv8p1RVeJ6XljqAe3GzeiJIAX/zxdZ2Dy7yVpPquolKzFJpFOKUiUNVGYKGI1OZInshRYM9Dq2n2gnj8cmKvyWfPln7jR52X7Cvu3zVYE11Qz31UFEFU5PSKlyZbL2CxiLyI628IQFUPDkwqoyDwWlk8fcGefLVuMxu3NDCwWzvG//zxQOUysmds//ztabSGo8f15W/zl4UtRkpm7r5dYHl7UQSXBXb3AuDRxZ+y2/bdqLdYxEB2ttOeHdvQr0tVANLkD0mtqUkOnzK5P7c/l/0CtSBa7HfPnOxLTyOVWaWYBovjy5puBuLofsHNOPLiYuKpwO5eANzxwof8/LARPLzo07BFCY1u7StZsXZTi+M2tdZIhI0R5B9eVhavFZE1cZ+P3BCTA3MhZBjc+J8lXPXwmy2Or9m4hS+/blnpbbEeAVBcLbpMSPStyNY/RhNR9Uqb7bqKfMHL9NFrgAtwXEv0Bb6P4330LuCW4EQLh7Ubt/DastX84tG3mP3Uuy3OT/j544z9WUsbdqG1EPzA61eSy6/Or3stvCS84ONn7JG9rXjPIdnH88hFa/24Cf3yLrC7F/b0QYHluxvqA1T1ZlVd68YPmAMcqKp/BQpu5Oi02+cz/Yb/JT2/cUt+tPx7dsj/hVF+K8ceHcKL4BRPxxCDiHgZTwm6zvbT7LdTbadm+eZbYPdEpCr9M7P28pTHUWP7pU+UI7wogkYROVpEStzP0THnCs4O8NIHK7O6Lpd+QnYdXBNo3NhCJvaBra4Ix92En0SxJxpFmTPB6xToPYe27EWcHlJsBC+K4ATgJOBz4DN3+0QRaQucFaBsoZCtZvty3eb0iXxi50E1ofnMOWVyfy4+aFgo944ao/p12rodlUHQVPhVgRfCdxEUs6YO5X8/3DPn9/Uya+g9YHqS08ltKBGloTG7p/Tyh173WZL8pK6m2pM3zUwo1MAg7SvTz86uKHXaYgXeSDY8IAJlpSX07Zz7qdT55wPAMCJIOq8ryWZT/fKoUdz6zPuMr8t/n0PWkt9GEI2XvPU11FpE5AAReUtElojIrATnO4rIP0RkoYgsFpFTg5QnKBqz7EUY/nHfGVPCFiErenZsw4UH7kBJBo6HvFTIftYplWX+VBP5OCYzJmagOv8JTlMEpghEpBS4EZgKDAOOE5F44/KZwOuqOgrYA/hVTDD7yDDwR3PTJzICpZ0HM0w8rX2tvr1bwS6jacaw3v4Eopl/0b6+5OMn956xc9gibCX9hJPgGpxeFpRVisjxIvIjEbm46eMh7wnAElV9zw1scxdwSFwaBdqL089qB3wF1GdYBiOPyGb2lB/tnGSvyIs/3tuH3IubRD2QeDNGspkysSE627o9Alt0mH946RE8gFOB1+M4nWv6pKMP8FHM/jL3WCw3ADsAy3HiHZzrejxthojMEJH5IjJ/xYoVHm5dBPjcS9yuW3IfMkN9HhzOJd3bN19v0cw5ag6NsokrU//uH6RL6yZSiTs8Sa+hTYCz256dtRf3fCeaJsHsCO5H9tKf7quqB2SRdyKp41+H/YFXgL2A7YDHROS/qrqm2UXOIrY5AOPGjbPmRAAcNLI31z3xTsJzdV2refPTtUD6RzHfW3v5JF22YT0qEtjsdx3cjafejkYjya81N707taVLtT+W5EN36tNq76P/Pn93tjRk/4Tl+2DxsyIyIou8lwGxS+f64rT8YzkVuFcdlgDvA0OzuFdREcTzEuZDGNa9WxtfSZNsp0vbWvp1Tr9gyc/7Nf0+qb6udL9hXddtUyLzsbEwZbuajNInGkAf2K2d71OrYwmyZ+5FEewCLHBn/7wqIq+JyKserpsHDBaRAe4A8LHAg3FpPgT2BhCRHsAQ4D3v4hcnuvWPYWTPwaN6e0qXjZ5uGkhvUradfWq55wtn7z3Y9zxTfc9Lfj6VugDjgXsxDU3NJmNVrReRs4BHgVLgFlVdLCIz3fOzgcuB20TkNZzv4Yeq+kU29zOCo1BdArTWRt/aIC1hu+mePqo3Dy6M76RnR3xvYWCKMadcumMJilxPhS0rDXSmv6eVxR+IyChgV/fQf1V1oZfMVXUuTrD72GOzY7aXA6G6Gpzxx/lMH9Wb6R5aR39fkB8RjAIxDUX85QxjsdP+w3tyzl6DuP7fS3J633zoDHr2LFuorYgCw8v00XOBO4Du7ufPInJ20ILlin+9/hln3/myp7QPvPJxwNJkQAG9X1GuLLq2yx+PqE3sMaSbr4+HF8WTjz9h+zbmOMErXvobpwETVfViVb0YmAR8K1ix8pOKgLtnfjF5YNec3zN2MDAq5LLuymWP5fJDgvFM65vTubzo0+QhIWpTLzWbAA0x+w0UVHs0miQz5Sy9ahp3zpiUeX5x2f36mFFJ0iW+7z/P2TWQxVvHT6z1Nb+gHtx88sNT7rHBkul3kaqMQ3v6s/q4mMn3wDS3Ai+IyKUicinwPPCHQKXKM1at38xvn3w3r9oxQbeqDhkVv/YvNdWVZS0Wb/mB372w8H5D/+6cTun43bD0kt2g7u0SHm/tFF0/8XP6ZZTNmYlI+5ap6jU48/2/AlYCp6rqtQHLlTeoKhfe+xpXP/Im897/KuPrU63YzZZEC4r8JtvnPOqDzoVAvv8CYT0j952xc7NoaMY2ktYoItKl6QMsBf4M/An4wD1WFHzztnk8vOhTADZnEaA+G2do6ThhYv9m+/sO69HqPPO98khHWHbnMBqG6cpa7fGZ8/qNJWr9ei13omvD/K1Kc/yDPf693fnvD3IfaCZTUjUtFwDz3f9N2/NjtguOJZ+vbXHsP29tW7afL73c+B7BQSN7hSRJS2wgMHw8K4K4B7pzVTl/OX1i2nRhcue3mo9/5buFZlD3dp5iTEO4ZUn6xKhqOMEzQ+TDr9anPJ9PlVzQ3esgbKCLL9vf9zzzhXTPRq7r0mxud/mhOzJlUGauFprIVSU2YUD2xoh8VxphipdUEYjIUFV9U0TGJDqvqi8FJ1ZuiG/ppKv8WuNQyi8unZ77eMHpXqByj64vvbZUY6kKcgVnyBVD2PVS/POerHHhpVGQR52GlEREzJyT6s38HjAD+FWCc4rjMTSyvLpsFQff8MzW/dXrt/CDv3txoZQf+N078W7zbXnsTwnMCX5QWVbC2XsN5qYn3w0k/1zi66+V4whl+UxUFFC+k8o0NMP9n/8jHVnw/HtfNtvfsKWBFWs3hSRNtNmuW+Kpg63lrD0HbQ1m4hd+V5Ctya+Q6rBcmV0KWcGFOSXVi4uJo0Skvbt9kYjcKyI7BS9asCxftbHZ/qQrnwhJkuywaZrO4rkmvLYMC6nyDZI25dFYRe8nd8+cHOr9y0vDe6e9GG1/oqp3i8guOIFkfgnMBoKxB+SI255dmpP7lGYZOqpteSkbtjSkT+gThbZAxhMha4Wwv/Fks4FevXQ/SkUYfsmjKdL5K/1j392N+sbMfxA/H9vOVeWAs/bn3RVegjD6i9cV4UHg5c5NtdE04Leq+gBQWM7FA6QpUMU3ptSFK0gEiZJuStcj8XMKZlD6q+n77tCmvNnAvpdGQibz8xOtFh/coz079GrppqKY3puyXMQbTYIXRfCxiNwMHA3MFZFKj9cZQFPLqVv7/PNSWYz07OC/G4yo4nlBWZrzd82YlFFr9iCPAXESytKKutKrOTWsjmK+9wiOxgkuc4CqrgK6ABcEKZSRe3bfvlvYIgTOraeO56CRMZVQDhtgflYufnUu/Cj+6H6dmDSwK5O3a+7x9oDhvRjdrxNn7TmoxTW5Xt3rnXDlOmpcv/SJAsKLr6H1OC4mprpxCHqp6r+8ZC4iB7ghLpeIyKwE5y8QkVfczyIRaSgm9xV+0dqKYelV0xiWoFueiHSvSj4PYu85pLsv5qaLpu2wbSdvK7X0+DkuVF1Z1mzwvmNVOfefubPnVbXZksmzr2herZKOp0+n9LGog8LLrKGLgduBrkANcKuIXOThulLgRpxQl8OA40Sk2WooVf2Fqo5W1dHAhcBTqpq5Z7cIEOH6IiPyafV1Lhhf54Sr3G94z5AlyZx8rhTDoXi/Dy+moeOA8ap6iapeghOY5gQP100Alqjqe6q6GbgLOCTNfe70kK8Rhx9KJlUeYdouveK1TvNbHw/t2YGlV00LzLQW5Epyr9VewjlDITVsWqyGDkCOImmzNcPLG74UiB1hqwS8LPXsA3wUs7/MPdYCEakCDgDuSXJ+hojMF5H5K1asSJSkqAm6YXfJ9OHB3iCHaNKdgO/r471ie129OjrmhLH9O7c632KsAA0HL4pgE7BYRG4TkVuBRcDXInK9iFyf4rpEz1Wy12E68Ewys5CqzlHVcao6rlu3wh3U/MlBufcj5IUu1cHMFp66o3/mlGIxvcUzpGd7njh/94SDsn5RpF+tZw7IwCw4a+rQACXJHi8Lyu5zP0086THvZUDsMHhfYHmStMdS4GYhL4Oo00f14vKHXs+BNM5c7tj4CmEsKLv+uJ1Yvyn5orlMZBrSw7/oU0Hgpz0+PhKcXy4+snkEomRVD2oiw+yTxnpOO2W77Ly7Bk1aRaCqt4tIW6BWVd/KIO95wGARGQB8jFPZHx+fSEQ6ArsDJ2aQd6uozyLATL7R2nr7F0eNZFD3drzz2df+CJQF5aUldKzyZ/yhJJvFONlGYfNJaWabzRAfQy7GUuhjx/nmKjyf8DJraDrwCvCIuz9aRB5Md52q1gNn4axBeAP4m6ouFpGZIjIzJulhwL9UNWdruq99/J1c3Sojcj31cnjvjhy6U2axifPBBvPNnQdw7TGjwxYjI3aqbb0NP5bqIN1zx5EHP3lOKUZ3K15MQ5fizAB6EkBVX3Fb+WlR1bnA3Lhjs+P2bwNu85KfH+x81b/5eNWGXN3OCIAZuw2kZ8fwVghnY+a56YQxW3335CuZ1H9+VpXXHD3ax9xS4+WXK8ZptV765fWqujruWGS/KVMCuSMoE0YUySYoT9B4re9+PG0YQ3u2Z8c+2xYdNjlTbFPWOtPe9FG9GVBT3ao8/KIIOwJb8fJ0LhKR44FSERkMnAM8G6xYwbB6/ZbQ7u3lIYtNE3V75sQBXVoMahY6/zxnF15btprO1RV8+08LwhbHN0b368Qj5+3W7NiIPh05b5/BHDehNicyjOzbkU1bWj+2V8R1fUq8qPOzgeE400j/AqwGzgtQpsA4+66Xc37PTq5r21zadL2QtR00jQbKZxcTLfBZmQ7v3ZFjJ9QGG14zULz/diLCeftsT48cOfE7dHQfHv3ubukTpiHP20+h4WXW0Hrgx+4n0ny8MnVw+iA4d+/B9GhfycGj+vCTBxanTCvNtlO/lK3txgZlBy00FxPd2lda5LoiId972UGS/74DIk6b8lK+sfMApMi+6UjYW6MgY8Rp38Zpa/ZP4nxuTG2nVuVfEsCDVoyzhoqsegqPQnm0xg8oPuewx47vx/n7br91vxgrimzZvkd7fn/yOK44fETC860NPFNeWsKcmAVdTaZYIzNMEeQR2VYwuTDHtHNnvYTpKtd3PH5tVx0xkrP3Huz77SM1ntIK9hnWg6qKllboTlXlSZ/5UX07es4/1vNr/67VfHef7VOkNhKRdoxARLoB3wLqYtOr6jeDE8u4/NAd+f7dC5OeLwZ7ZtAN78ryErIx//s1vhL+eErz++dTR+f+M3cG4LJ/ZO5yZWS/5EqkGN6bbPAyffQB4L/A42yLX2wEQOx7eOTYvikVQfPr8ugNjgjt8nBev7GNKJjfTttlgOeATvmOl7ehSlV/GLgkBU6QD3b4LcvocdDIXjz2+mdhi2HkiGG9OlBe4q8l3A9vwb86ahTne2zwBYmXb+YhETkwcEmMwMjGH5thFAo71XZi7rm7ZueYMGCOGNuXoXmwAj+pIhCRtSKyBjgXRxlsEJE1MceNNJS18sHr0aGy1TIcOro3Cy/Zr9X5FCJhWx/MpBctfnXUqLBFCIykikBV26tqB/d/iaq2jdkvDMNYwMw9d9eMr+nbuS2d3SlwtSkCf3utxDq2Lad9G5tSV2j80A1wkszXj5fno3vcquBcqaUmv0vn7OX/TKwgOWJs37BFCAwvs4aeUNW90x0zWrJ9TLAULy+ZCPz3B3t6ytvr7Iew4g3b7IxgOXlyHSdPrmtVHl0DijyXjoqyEpZeNS2UexuJSaoIRKQNUA3UiEhnttVlHYDeOZCtKMlmUDlVpXvevjan2m+iMKPFiyI2Zd2cYv46UjUXvw3MB4YCLwEL3M8DwI3Bi2b4QVjTJP2oK/PVhu7XOoJbTx3vSz5emLn7dmnTREHBtRYvv1zhfwstSVpLqOp1wHUicraq/iaHMgXGB1/m3ulcLiiC97cg2XlQfsWvLcaALLniZ4fuGJopzgupZg3t5W5+LCKHx3+8ZC4iB4jIWyKyRERmJUmzh4i8IiKLReSpLMrgmfrGwnzQ7f3Njt0GdwtbBKNIOHFSf6aO6BW2GElJZRra3f0/PcHnoHQZi0gpjglpKjAMOE5EhsWl6QTcBBysqsOBozKUPzJ4CkyTx53SMFqLQfd0rjxiBE9f4G1wvhiIsmloynZdwxYh0qQyDV3i/j81y7wnAEtU9T0AEbkLOASIdR5yPHCvqn7o3uvzLO8VKX551KiE7iMyWSGc6WrifXbozuNvhPf1HjiiZ/pEOaayrJTarsmn6BrR4ZZvjGfNBn8iEMa+WQO7VXPLKeOpLC9s/5xpSyci74rIHSIyM75Fn4Y+wEcx+8vcY7FsD3QWkSdFZIGInJxEhhkiMl9E5q9YsSIDEfKTbCJYNdkX998xuwr196e0bmCyta3FkX07ZXxNUyfkG1Pq+OuMSa26v5Ge6PYHnLgf8esiEjF9ZGbmmUfO3Y26mmp6dSwgr7sJ8DKlZBgwEdgV+KWIDAUWquphaa5L9FzFN2PLgLHA3kBb4DkReV5V3252keocYA7AuHHjCtYinso09MysvWhTXuopbaFx6cHDwxYhckTYyhMop+0ygBMm9meHix9Jmib2q6tIsmCv0PCiCBqALe7/RuAzwIuNYRnQL2a/L7A8QZovVHUdsE5EngZGAW9TYOS64j5tlwFMHhhtu2mmldnAbtW8t2JdMMIUAT075ib+cJiICG0jG1M6OLyouzXAtcD7wCmqOllVv+3hunnAYBEZICIVwLHAg3FpHgB2FZEyEanC6Xm84Vn6PGPHPts8b4zq1yk8QXA8I+4zrEeoMsSSCzV4z8wp7JJnUzL9ZnD3dr7l1dS17telLQ+dvQs79vEeDCZMfnHkSG75xriwxSgovCiC44CngTOAu0TkMhFJ615CVeuBs4BHcSr3v6nqYnesYaab5g3gEeBV4EXg96q6KLuihM9fZ0zeuu1HxRfWtND/fH+PVucRL3suitK5uoIRGUS2iiJzTs6uAiwvdZ7IWPNiEyUikVECAEeN68deQ5M3cka541Hf2nVgjiSKPmlNQ6r6APCAOzYwFTgP+AGOTT/dtXOBuXHHZsft/wL4hXeR85fqAFfxxptJgoxBMKCmusWxQlls1DToHtXBP68NjPifa+dBNZSIcMqUOh5e9KnvcuUTXaorWHrVNDZsbuChV5dz0bQdwhYp7/Eya+geEXkXuA7H99DJQOegBYsqTUv5O/sQRNurjTyXdbTX2UP+uJjwn32H9WD2iWM5c8/0LhcKiRIRvrvv9nRJsLq1UMeV21aU8q/v7s7Y/l08pS+Qtk5WeGnCXgW8pKoWptID4/o7OrKkQKdtRL1nICIckOUUXKM4KNBXNyVpewSqOs+UQI5I8QCmmnWUiwc3yqtOM2HiAKf12JqVqjv2duzt39otv23Ule7UyD6do2kmM/zDInhHlFjFEPFGel7x129P5pPVG2hoVHa5+j9Z5dHZtVH7Reeqclaud1bN+qmPe3dqy00njDH3DHEU4/tUHKsl8oAiaVBHkuuOHd1sv1fHtlSkCOjTt3Nu3VLcd8bOGV/j9Xk7cEQvOlXlr1fMXFLM76jXweJpImJKwwPZNCbae5htlGrWUBQe4AiI6JlcjzHU1VSnDFtqGK3Fi2not8CpwPUicjdwm6q+GaxY0SeTyrm1PdFcdGWjPkgcdX538jhue/Z9+qXojbz8k30L1tV6LijmR9zLYPHjqnoCMAZYCjwmIs+KyKkiYlHRPRL7kLVJ4skwEi37KAhZgAzp2Z4rDx9JSUny779zdQXd2lfmUKrCpBgfcU/mHhHpCnwDOB14GWdNwRjgscAkizipWhcTByQenEt1TdSfzWwaW8X4QhpGGKQ1DYnIvThxi/8ETFfVT9xTfxWR+UEKF0WS1V1NlVplWUmLCs7qu/yjpl0l+w3rwYw8nwKajGI2cxiZ46VHcIOqDlPVK2OUAACqap6fWkHb8tJm0wzzrQX8j7N24YL9hzQ75nWsoClZVD2glpQIc04ex7g6b6tSDSPKeFEEO7ghJQEQkc4ickZwIuUfh4zu7TltNg2xHq7731SrkeNt83Vdt/kDCqrxN6JvR87cc1DC+3tlZIE7gTMKhyD9d+U7XhTBt1R1VdOOqq4EvhWYRHnIdcfuxINnZTaXO1m9mehRu+P0iVx7zGjaZeC0rnen/F4N2lT+1rxaxRR8x8gfivG586IISiSmOegGpS+6FSjZhFr0So8ObTh0p/gont7JxWPb2umj2chYzC201pJvZsYoUYzPnRdF8CjwNxHZW0T2Au7EiSEQKfJpHny5u2p1+qjM4qcmI5cly8X00e42BdIIgWLsCTThRRH8EPg38B3gTOAJnHgEkcIPPTCsV4f0iTxQXlrCKxfvyxWHjfB8TTE9ogePcsZkCu3FnHvOrlvHTL69ezRnIxmFiZcFZY2q+ltVPVJVj1DVm716IxWRA0TkLRFZIiKzEpzfQ0RWi8gr7ufibArhBT9azSU+OtnoVFVBWQp/NkbhMax3B6bu6E8v0DD8JOnopIj8TVWPFpHXSFCPqurIVBm7Ywk3AvviBKmfJyIPqurrcUn/q6oHZS56ZjTmkWnIMIz8I5/GBv46YxLLVm7g/LsX5uR+qaapnOv+z7aSngAsUdX3AETkLuAQIF4R5ISo64F8GfzLxViL33e46YQxCcNvGkYi8sEkOXFgVyZC+IqgafGYqn6QZd59gI9i9pcBExOkmywiC4HlwPdVdXF8AhGZAcwAqK2tzUoYP3oE+fCAhEVrB4mDcjFx1eEj6N4h9eDygSPMHGP4w/f23b4gJzOkMg2tpfn7K+6+AKqq6UZOE73G8fXBS0B/Vf1aRA4E7gcGt7hIdQ4wB2DcuHGhte19aZUHIP2OfTIfxB5Y0y6j9Nn2BIJWncdOSN4wGFPbKeC7B8fgHu0B6N81u55M1HvAYVNRWsLmhsYWx8/Zu0X1VBCk6hG0b2Xey4B+Mft9cVr9sfdYE7M9V0RuEpEaVf2ilfduwfJVG/zOMiNaq0RStciH9sxMETw7a6+sF6R57Rk0VURh1UenTO7PrKk7hHT31nPCxFpG9OnIqH6dQpPhxuPHhP7ehMWCn+xDY0s9ULB4WsoqIqOAXd3dp1X1VQ+XzQMGi8gA4GPgWOD4uHx7Ap+pqorIBJxZTF96FT4T7nv541bnUSiGoVRKoFNVMJ7Fc/3dde/QhrYVpTm+a3oO3ak3f3puKcen6MnsP7wHIhKqEgCYNjJzk9pRY/tSncEK+bDYd1gPHnv9s6Tn27cpLg/7XryPnovjUuJe99AdIjJHVX+T6jpVrReRs3AWpJUCt6jqYhGZ6Z6fDRwJfEdE6oENwLEa0Gik1zGCb0yp47ZnlyY+maI1fKjrjyiXC9fO2nMQew7t7lt+954xhb4+ua7Il8HtfKNXx7Y8e+HeKdPccPyYVt8nrO//F0eNCufGGTL7xLHUxzX5mxpIp+5cF4JE4eJFdZ8GTFTVdQAicjXwHJBSEYBj7gHmxh2bHbN9A3BDJgJny/rNnpY+MLRnay1iTSR+EzN5QU+ZUse8pSuTnv9+nGfQ1jKmtrOv+RmZ8ZvjdmKHXh22rjw3gqO0RCgtad5j7NCmvJk34GLCyxMnQGwt2kAErSRPvPG5p3Rj+nfm0unDEp5LVeiW/YDmRyrLSjl7r0EZBSI/aKR3r6dG9Jk+qjeDumc2iG8YfuClR3Ar8IKI3IdTFx4C/CFQqQLA62IRAY4ZX8ul/2i53KFrdXpfe6kGU8/fz98WfKYM7dmenSIwk6Y11rURfRwXDjv08qtnZ4TJ8N7ORIjtTEEGSlpFoKrXiMiTwC7uoVNV9eVApcpTfnX0KEb/NHF0zih0kR45b7esr73yiJFc/fCbtC3PvwHYWA4c0YunLtgj62mXRn5x5Ni+jOrXie17mGIPkkyMkbHrCIqSTlXpewT55OXUTw4e1ZtnZu1FaYrg6fmCKYHUHNYKl+e5RkRMCeSAtIrAdQR3O9AZqAFuFZGLghbMb7zWzyJ++RzJ/wozF+ztzmqasl1Nq/NqmpZoM5Jax6+PGV20g6JGYryMERwH7KSqGwFE5CqcFcE/C1KwfKGXG0bSyI6JA7tmXOkkU8S3nzqBhxd9Qo8O9psYhUPTehc/vRtnipdbLwVi37xK4N1ApMlD5pw0LmwRipb4gfd+XaqYsdt2IUkTLQ4f0xeAbgXoF6fQuOmEMXxv3+0ZEqIJzEuPYBOwWEQewxkj2Bf4n4hcD6Cq5wQoX6D89JDhXPxACx93W+dxnziplhERCb7+9AV7suLrTWGLsRU/hkrybbzlvz/YMzLuzCe5PbGjZj/LirX581wYLenVsW3oPoy8KIL73E8TTwYjSrAken9PnlzXQhF0bFtBeWkJiy7bP+9nyMRS27WK2q5VYYtR0PTrYt+vUZh4mT56ey4EyQeeu3CvrV3pdln6S+nazrl+u27FPXPFjwHdXMRHNgzDo9O5YqFXx9b72RnbvzN/OX0i4wd08UEiwzCM4Ckapya5tDdPGVTjm7+YXQa1ftqlYRjRJRcD/qkC0/xJVU8SkXNV9brAJQmYSQO7cq8PrqiTEZSa+d3J4/hyXXEN9kVkPNYwAuf1n+5PSQ5MpKlMQ2NFpD/wTRH5I3ErpFT1q0Al85kObaPpX7xtRSl9K4pzkNJGCIxip6oiN9b7VHeZDTwCDAQW0Py9VPd40TL/on2orihjh4sfCVuUULn11PFhi2CkYMKALsxburIg4+wa/pEqVOX1wPUi8ltV/U4OZQoEv3sENe2av1jF2HqdNLALew7xLzCO4T/f23cIR43tR11Ncc9iM1LjZfrod7IMVZlXnLHHdqzZsGVr9LGHzt4l9QVGaAx0p9726exPtLRiprRETAkYafHidO4c4A6gu/u5Q0TO9pK5iBwgIm+JyBIRmZUi3XgRaRCRI70Kniltyku59ODhW/d37OPvimGb8+4fJ03qz19nTGL/4T3DFsUwigIvcxxPxwlVebGqXgxMwolhnBIRKQVuBKYCw4DjRKRF6C833dU4sY1zzpuXH+BLPvnmDiHKiAgTB3YNWwzDKBqCDFU5AViiqu+p6mbgLpzoZvGcDdwDeIsl6TNtfHIjYWrAoSkWQJRa8yP7dgpbBMMIlUxDVQIcirdQlX2Aj2L2lwETYxOISB/gMGAvIOn0ExGZAcwAqK2t9XBrIyz6dGrL4sv2p6oiOn6aBpgN3Shy0vYIVPUa4FTgK2AlTqjKaz3knajXEN9wvhb4oao2JEgbK8McVR2nquO6devm4dZGmFRXltmYiWFECE+rFVT1JZxgNJmwDOgXs98XWB6XZhxwl1tp1AAHiki9qt6f4b0MwzCMLAly2do8YLCIDAA+Bo4Fjo9NoKoDmrZF5DbgIVMChmEYuSUwRaCq9SJyFs5soFLgFlVdLCIz3fOzg7p3GEwcYLNcDMOIJmkVgVuZ36GqKzPNXFXnAnPjjiVUAKr6jUzzz4aBNdW898U63/Lr0KaMNRvrmTail295GoZh5BIvPYKewDwReQm4BXhUIzxp/r4zdubztRvDFsMwDCNv8DJr6CJgMM6U0W8A74jIFSISySjiHavKGRxikGjDMIx8w1P0FLcH8Kn7qQc6A38Xkf8LULZIobakzDCMiOJljOAc4BTgC+D3wAWqukVESoB3gB8EK2J+Y/PlDcOIOl7GCGqAw1X1g9iDqtooIgcFI5aRzwxxTWsnT64LVxAf6di2nNUbtoQthmGEghdFMCBeCTSFsVTVNwKSKzJEeNw8a7q2q2TpVdPCFsNXnvz+HqYIjKLFiyIYHrvjegsdG4w40UWKMjRN4dC5uoLO1RVhi2EYoZB0sFhELhSRtcBIEVnjftbieAl9IGcSGoZhGIGSVBGo6pWq2h74hap2cD/tVbWrql6YQxkNwzCMAElqGhKRoar6JnC3iIyJP+86ojMMwzAiTqoxgvNxIpH9KsE5xYkhYBiGYUScpIpAVb/l/t8zd+JEF1tQZhhGVEllGjo81YWqeq//4kQPW1BmGEbUSWUamp7inAKmCCjOdQSGYRQWqUxDp+ZSkKjQuaqcletbLjyydQSGYUQVL76GegBXAL1VdaqIDAMmq6qXAPYFxz/O3oXFy9eELYZhGIZvePE+ehtOlLHe7v7bwHleMheRA0TkLRFZIiKzEpw/REReFZFXRGS+iOziUe7Q6Nu5iv2H9wxbDMMwDN/woghqVPVvQCM4ISiBhnQXua4obgSmAsOA49zeRCxPAKNUdTTwTRzvpoZhGEYO8aII1olIV5wBYkRkErDaw3UTgCWq+p6qbgbuAg6JTaCqX8dEO6tuuodhGIaRO7w4nfse8CCwnYg8A3QDjvRwXR/go5j9ZcDE+EQichhwJdAdSOjSUkRmADMAamtrPdzaMAzD8IqXUJUvAbsDU4BvA8NV9VUPeSeaRtOixa+q96nqUOBQ4PIkMsxR1XGqOq5bt24ebp17bEGZYRhRJZsFZduLiJcFZcuAfjH7fYHlyRKr6tMisp2I1KjqF2nyzhtsQZlhGFHHy4Ky7ji9gX+7+3sCT5J+Qdk8YLCIDAA+Bo4Fjo9NICKDgHdVVV3HdhXAl5kUIGxsQZlhGFEn7YIyEXkIGKaqn7j7vXBmA6VEVetF5CycqaelwC2qulhEZrrnZwNHACeLyBZgA3CMRrRmtQVlhmFEFS+DxXVNSsDlM2B7L5mr6lxgbtyx2THbVwNXe8nLMAzDCAYviuBJEXkUuBNnsPdY4D+BSpVj9h3Wg85V5WGLYRiGEQppFYGqnuUOHO/qHpqjqvcFK1Zu+d3J48IWwTAMIzS89AiaZgiZt1HDMIwCJNX00f+p6i5uwPrYAVwBVFU7BC6dYRiGETipegQnALgB7I002IIywzCiSqqVxVvHAUTknhzIYhiGYYRAKkUQOzF+YNCCRB1bR2AYRlRJpQg0ybZhGIZRQKQaIxglImtwegZt3W2wwWLDMIyCIpWLidJcCmIYhmGEg5fANIZhGEYBY4rAMAyjyDFFYBiGUeSYImglVRWevHQYhmHkLVaLtZI7Z0zi4UWf0NG8lxqGEVGsR9BKBtRUc8Yeg8IWwzAMI2tMERiGYRQ5gSoCETlARN4SkSUiMivB+RNE5FX386yIjApSHsMwDKMlgSkCESnFiW08FRgGHCciw+KSvQ/srqojgcuBOUHJYxiGYSQmyB7BBGCJqr6nqpuBu4BDYhOo6rOqutLdfR7oG6A8hmEYRgKCVAR9gI9i9pe5x5JxGvBwohMiMkNE5ovI/BUrVvgoomEYhhGkIkjklzmhF1MR2RNHEfww0XlVnaOq41R1XLdu3XwU0TAMwwhyHcEyoF/Mfl9geXwiERkJ/B6YqqpfBiiPYRiGkYAgewTzgMEiMkBEKoBjgQdjE4hILXAvcJKqvh2gLIZhGEYSRDW4mDMiciBwLVAK3KKqPxeRmQCqOltEfg8cAXzgXlKvquPS5LkiJn2m1ABfZHltvmFlyU8KpSyFUg6wsjTRX1UT2tYDVQT5hojMT6doooKVJT8plLIUSjnAyuIFW1lsGIZR5JgiMAzDKHKKTREU0splK0t+UihlKZRygJUlLUU1RmAYhmG0pNh6BIZhGEYcpggMwzCKnKJRBOlcYucDInKLiHwuIotijnURkcdE5B33f+eYcxe65XlLRPaPOT5WRF5zz10vIoncfQRZjn4i8h8ReUNEFovIuREuSxsReVFEFrpluSyqZXFlKBWRl0XkoYiXY6krwysiMj/iZekkIn8XkTfdd2ZyzsuiqgX/wVnQ9i4wEKgAFgLDwpYrgZy7AWOARTHH/g+Y5W7PAq52t4e55agEBrjlK3XPvQhMxvH39DCO+45clqMXMMbdbg+87cobxbII0M7dLgdeACZFsSyuDN8D/gI8FNXny5VhKVATdyyqZbkdON3drgA65bosOS1wWB/3y3k0Zv9C4MKw5Uoiax3NFcFbQC93uxfwVqIyAI+65ewFvBlz/Djg5pDL9ACwb9TLAlQBLwETo1gWHH9fTwB7sU0RRK4c7n2X0lIRRK4sQAecuCwSZlmKxTSUqUvsfKKHqn4C4P7v7h5PVqY+7nb88VAQkTpgJ5yWdCTL4ppTXgE+Bx5T1aiW5VrgB0BjzLEolgMcT8b/EpEFIjLDPRbFsgwEVgC3uia734tINTkuS7EoAs8usSNEsjLlTVlFpB1wD3Ceqq5JlTTBsbwpi6o2qOponBb1BBHZMUXyvCyLiBwEfK6qC7xekuBY6OWIYWdVHYMTAfFMEdktRdp8LksZjjn4t6q6E7AOxxSUjEDKUiyKwJNL7DzlMxHpBeD+/9w9nqxMy2ge6S2UsopIOY4SuENV73UPR7IsTajqKuBJ4ACiV5adgYNFZClOtMC9ROTPRK8cAKjqcvf/58B9OBERo1iWZcAyt5cJ8HccxZDTshSLIkjrEjuPeRA4xd0+Bcfe3nT8WBGpFJEBwGDgRbcbuVZEJrmzBk6OuSYnuPf9A/CGql4TcyqKZekmIp3c7bbAPsCbRKwsqnqhqvZV1Tqc5//fqnpi1MoBICLVItK+aRvYD1hEBMuiqp8CH4nIEPfQ3sDr5LosuR7kCesDHIgze+Vd4Mdhy5NExjuBT4AtOBr+NKArzgDfO+7/LjHpf+yW5y1iZggA43BejHeBG4gbiMpBOXbB6Za+Crzifg6MaFlGAi+7ZVkEXOwej1xZYuTYg22DxZErB45dfaH7Wdz0PkexLK4Mo4H57jN2P9A512UxFxOGYRhFTrGYhgzDMIwkmCIwDMMockwRGIZhFDmmCAzDMIocUwSGYRhFjikCo+gRkQbXi2XTJ6V3WhGZKSIn+3DfpSJS09p8DKO12PRRo+gRka9VtV0I910KjFPVL3J9b8OIxXoEhpEEt8V+tTjxCF4UkUHu8UtF5Pvu9jki8rqIvCoid7nHuojI/e6x50VkpHu8q4j8y3UudjMx/mFE5ET3Hq+IyM0iUhpCkY0ixRSBYUDbONPQMTHn1qjqBJyVmtcmuHYWsJOqjgRmuscuA152j/0I+KN7/BLgf+o4F3sQqAUQkR2AY3AcqY0GGoAT/CygYaSiLGwBDCMP2OBWwIm4M+b/rxOcfxW4Q0Tux3EPAI6LjSMAVPXfbk+gI07gocPd4/8UkZVu+r2BscA8N6hUW7Y5GTOMwDFFYBip0STbTUzDqeAPBn4iIsNJ7RI4UR4C3K6qF7ZGUMPIFjMNGUZqjon5/1zsCREpAfqp6n9wAr50AtoBT+OadkRkD+ALdeIxxB6fiuNcDBynYkeKSHf3XBcR6R9YiQwjDusRGIY7RhCz/4iqNk0hrRSRF3AaTcfFXVcK/Nk1+wjwa1VdJSKX4kScehVYzzZ3wpcBd4rIS8BTwIcAqvq6iFyEE3GrBMf77JnABz6X0zASYtNHDSMJNr3TKBbMNGQYhlHkWI/AMAyjyLEegWEYRpFjisAwDKPIMUVgGIZR5JgiMAzDKHJMERiGYRQ5/w8AIGZ+a7sg7wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAX10lEQVR4nO3df7RdZX3n8fdHfogKEQUcQyBGR2sNVFGigHQKCnUhoBkRB2VQ2k4HOtWOdnSpiB2wLTrWjssftBVGRS2i+AuiiAhYAVsRDRoFElCrgCRRgooBfwHynT/2Dhwv9z65ub/OvTfv11p33XP2efbe3+feZH/u8+x99klVIUnSWB407AIkSbObQSFJajIoJElNBoUkqcmgkCQ1GRSSpCaDQtqKJDk1ydmN169LcvDMVaS5wKDQhCS5Mckvk9yR5PYkX07yZ0keNNDmA0nu6tvckeTaJG9J8vCBNn+U5DdJ7uy/vp/krCS/M2J/D+7Xvbnf73eSvCZJBtpcluRXSfYcWHZokhun+cdBkoOT3DLd+5luVbVXVV0Gmw+Vyep/X386XdvX1DEoNBnPq6qdgMcA/wd4HfC+EW3+rm+zG/DHwP7AvyV52ECbK6tqR+DhwKHAL4Grk+w90ObjwCHA4cBOwEuBE4H/O2J/Pwf+agr6JqlnUGjSqupnVfVp4Bjg+BEH+E1tflVVXwOeD+xCFxoj2/ymqv69qv4cuBw4FSDJIcBzgBdW1bVVdU9VfQU4DnhlkscNbOZdwEuSPH48tSd5ZpKvJflZ//2ZA69dluRvkvxbPyK6OMmuo2zjYcDngN0HRka79yOfXfs2b0xyT5IF/fO/TfKO/vHDk3woyYYkN/Vtx/y/meSxSS7va7okyemb/vIfbWTTj/4OHVi0Q5Jz+/W/nuQpI9smOQx4A3BM359vjlHL05J8o9/Wx/vt/m3/2iOSXND366f94z36104D/hNwer/90/vlv9v36SdJbkjyX8b6OWjmGBSaMlX1VeAWugPAWG3uAC5ptel9aqDNHwJXVdUPRmzrqn5/hwwsXgv8P/qQaUnySOCzdOGyC/B24LNJdhlodixdqD0K2B54zSh9+jnwXGBdVe3Yf60DvgYc1Df7A+Am4MCB55f3j99NN5p6XN/+ZYwSpAPOAa4GdgX+Bjh+c30dYTndCO2R/bbOT7LdiD5dBLwZOLfvz1NGbiTJ9sB5wAf6bX0EeMFAkwcBZ9GNOBfTjRRP77d/MvAl4BX99l/RB+4lfU2PAl4C/GOSvbawf5piBoWm2jq6g8ZUttkVWD9Gu/V001qD3gI8bxwHmCOA71TVP/ejlI8A1wPPG2hzVlV9u6p+CXwM2Gcz2xx0OXBQkm2BJ9MF0kFJdgCeDnwpyTZ0I7GTquqOqrqRbjrtpaNtMMnift2/qqpfV9UVwGe2oCaAq6vqE1V1N1047kA3Jbil9ge2Bd5VVXdX1aeAr256sap+XFWfrKpf9H8gnMb9wTmaI4Ebq+qs/vfxdeCTwNETqE1TyKDQVFsE/GSK29wGLByj3UJgw+CCqtpA95frX29mH7vT/ZU/6KZ+35v8cODxL4AdN7PNQZcDBwNPA66h+2v5ILoD7Her6ja6ENx+RB331ZDkPQPTWW/oa/5pP4oZbL8l7huZVdW9dKOy3bdwG/TrrK3fvrPofdtO8tAkZ/TTaRuBK4Cd+3AczWOA/dJdHHF7ktuB/wo8egK1aQoZFJoySZ5Od4D710abHelOWH9pM5t7wUCbS+kOIHsONkjyDLopjStGWf9twLOAfRv7WEd3cBq0mG76akuNdhvmLwNPpOvL5VW1ut/+Edw/7XQbcPeIOu6roar+bGA66810I6hHjLgYYPHA458DD930pD8ojxxxDV4V9iBgD7qfxXj6NGg9sGjwyrPBbQOvpuv/flW1gG66DWBT+5Hb/wHdz2nnga8dq+p/bKYOTTODQpOWZEGSI4GPAmdX1TWjtHlwkn2B84Gf0s1dj2yzTX+i9t10f4m/CaCqLgW+AHwyyV59u/2BDwMfqqobRm6rqm6nm8J5baP0C4HfSXJskm2THAMsBS4Yf+/v8yNglwxc+ltVv6A7l/By7g+GL9NdrXV53+Y3dFNapyXZKcljgP8FjHpZalXdBKwE3pRk+yS/z29PlX2b7mT1Ef15hzcCDx6xmX2THNVPib0K+DXwlTH6tKRxYv1K4DfAK/qf33LgGQOv70R3XuL2/nzQKaNsf/BChAvofh8vTbJd//X0JE8aY/+aIQaFJuMzSe6g+0vwZLr57pEnYV/bt/kJ8CG6A+czR0ydHJDkTmAjcBmwAHj6iMB5IfBF4CLgV3QHqYuAExr1vZPuQDaqqvox3bz4q4Ef04XKkf2U0BapquvpTuZ+r5822TSVczmwHffP3V9OdwAdHAX9Bd1I4Ht0o7FzgPc3dncssB/dz/QUup/rpjp+Bvw58F66UcnP6aaWBq2gOy/yU7pzIUf15ytG+nj//cdJvj5Kn+8CjgL+G3A73VVoF9AFD8A7gIfQjZq+Qvf7GvRO4Oj+iqh39ecxngO8mG6E80PgrTww6DTD4gcXaS5K8kG6aa7D+wPWVivJqcDjq+q4WVDLVcB7quoBI0bNXY4oNFf9Kd3J4acNu5CtWZKDkjy6n3o6nu7qrpEjB81x2w67AGki+qmStw67DvFEunMsOwL/DhxdVWNdyqw5yqknSVKTU0+SpKZ5OfW066671pIlS4ZdhiTNGVdfffVtVTXyPTfAPA2KJUuWsHLlymGXIUlzRpIx3+Hv1JMkqcmgkCQ1GRSSpCaDQpLUZFBIkpoMCklSk0EhSWqal++jmKvOuepmVqyayGfm3G/5Pos4dr/Fm28oSePkiGIWWbFqLavXb5zw+qvXb5x00EjSSI4oZpmlCxdw7okHTGjdY864coqrkSRHFJKkzTAoJElNBoUkqcmgkCQ1GRSSpCaDQpLUZFBIkpoMCklSk0EhSWoyKCRJTQaFJKnJoJAkNRkUkqQmg0KS1GRQSJKaDApJUpNBIUlqMigkSU0GhSSpyaCQJDUNJSiSvCjJdUnuTbJsM223SfKNJBfMVH2SpPsNa0RxLXAUcMU42r4SWDO95UiSxjKUoKiqNVV1w+baJdkDOAJ47/RXJUkazWw/R/EO4LXAvUOuQ5K2WttO14aTXAo8epSXTq6qFeNY/0jg1qq6OsnB42h/AnACwOLFi7esWEnSmKYtKKrq0Elu4kDg+UkOB3YAFiQ5u6qOG2N/ZwJnAixbtqwmuW9JUm/WTj1V1UlVtUdVLQFeDPzLWCEhSZo+w7o89gVJbgEOAD6b5PP98t2TXDiMmiRJo5u2qaeWqjoPOG+U5euAw0dZfhlw2bQXJkl6gFk79SRJmh0MCklSk0EhSWoyKCRJTQaFJKnJoJAkNRkUkqQmg0KS1DSUN9xJ0+Gcq25mxaq1k9rG8n0Wcex+3lRSGuSIQvPGilVrWb1+44TXX71+46SDRpqPHFFoXlm6cAHnnnjAhNY95owrp7gaaX5wRCFJajIoJElNBoUkqcmgkCQ1GRSSpCaDQpLUZFBIkpoMCklSk0EhSWoyKCRJTQaFJKnJoJAkNRkUkqQmg0KS1GRQSJKaDApJUpNBIUlqMigkSU0GhSSpyaCQJDUZFJKkJoNCktRkUEiSmgwKSVLTUIIiyYuSXJfk3iTLGu12TvKJJNcnWZPkgJmsU5I0vBHFtcBRwBWbafdO4KKq+l3gKcCa6S5MkvTbth3GTqtqDUCSMdskWQD8AfBH/Tp3AXfNQHmSpAGz+RzF44ANwFlJvpHkvUkeNlbjJCckWZlk5YYNG2auSkma56YtKJJcmuTaUb6Wj3MT2wJPA/6pqp4K/Bx4/ViNq+rMqlpWVct22223KeiBJAmmceqpqg6d5CZuAW6pqqv655+gERSSpOkxa6eequqHwA+SPLFfdAiweoglSdJWaViXx74gyS3AAcBnk3y+X757kgsHmv4F8OEk3wL2Ad4848VK0lZuWFc9nQecN8rydcDhA89XAWO+z0KSNP1m7dSTJGl2MCgkSU0GhSSpaSjnKGarN33mOgBOed5eE1r/nKtuZsWqtRPe/+r1G1m6cMGE19+0jWPOuHJS25irpuLnJ+mBDIoBq9dtnNT6K1atndTBaunCBSzfZ9GE9z+ZdeeDyf78JI3OoJhiSxcu4NwTh3OT22P3W8yx+y0eyr4lzV+eo5AkNRkUkqQmg0KS1GRQSJKaDApJUpNBIUlqMigkSU0GhSSpaVxvuEvyBOAtwFJgh03Lq+px01SXJGmWGO+I4izgn4B7gGcBHwL+ebqKkiTNHuMNiodU1ReAVNVNVXUq8OzpK0uSNFuM915Pv0ryIOA7SV4BrAUeNX1lSZJmi/GOKF4FPBT4n8C+wHHAy6apJknSLDLeoFhSVXdW1S1V9cdV9ULA25RK0lZgvEFx0jiXSZLmmeY5iiTPBQ4HFiV518BLC+iugJIkzXObO5m9DrgaeH7/fZM7gL+crqIkSbNHMyiq6pvAN5OcXVWOICRpK7S5qadrgOofP+D1qnry9JQlSZotNjf1dOSMVCFJmrU2N/V006bHSR4DPKGqLk3ykM2tK0maH8Z1eWyS/w58AjijX7QHcP401SRJmkXG+z6KlwMHAhsBquo7eAsPSdoqjDcofl1Vd216kmRb+pPckqT5bbxBcXmSNwAPSfKHwMeBz0xfWZKk2WK8QfF6YANwDXAicCHwxukqSpI0e4zryqWqujfJ+cD5VbVhekuSJM0mzRFFOqcmuQ24HrghyYYk/3tmypMkDdvmpp5eRXe109OrapeqeiSwH3Bgkgnf6ynJi5Jcl+TeJMsa7f6yb3dtko8k2WGstpKk6bG5oHgZ8JKq+v6mBVX1PSb/wUXXAkcBV4zVIMkiug9KWlZVewPbAC+exD4lSROwuXMU21XVbSMXVtWGJNtNdKdVtQZGv3/UCNvSXWl1N90n7K2b6D4lSROzuRHFXRN8bdKqai3w98DNwHrgZ1V18Vjtk5yQZGWSlRs2eL5dkqbK5oLiKUk2jvJ1B/B7rRWTXNqfWxj5tXw8hSV5BLAceCywO/CwJMeN1b6qzqyqZVW1bLfddhvPLiRJ47C5mwJuM9ENV9WhE123dyjw/U2X4yb5FPBM4OxJbleStAXG+4a7YbgZ2D/JQ9OdzDgEWDPkmiRpqzOUoEjygiS3AAcAn03y+X757kkuBKiqq+juWPt1uneEPwg4cxj1StLWbCifKVFV5wHnjbJ8HXD4wPNTgFNmsDRJ0gh++NAIq9dv5JgzrpzwuksXLpjiiqStwzlX3cyKVWsntY3l+yzi2P0WT1FFM2sq+r909wWc8ry9pqii+83mcxQzbvk+iyZ1oF+6cAHL91k0hRVJW48Vq9ayev3GCa+/ev3GSR9oh2my/Z9OjigGHLvf4jn714g0HyxduIBzTzxgQutOdCZgNplM/6eTIwpJUpNBIUlqMigkSU0GhSSpyaCQJDUZFJKkJoNCktRkUEiSmgwKSVKTQSFJajIoJElNBoUkqcmgkCQ1GRSSpCaDQpLUZFBIkpoMCklSk0EhSWoyKCRJTQaFJKnJoJAkNRkUkqQmg0KS1GRQSJKaDApJUpNBIUlqMigkSU0GhSSpyaCQJDUZFJKkJoNCktQ0lKBI8rYk1yf5VpLzkuw8RrvDktyQ5LtJXj/DZUqSGN6I4hJg76p6MvBt4KSRDZJsA/wD8FxgKfCSJEtntEpJ0nCCoqourqp7+qdfAfYYpdkzgO9W1feq6i7go8DymapRktSZDeco/gT43CjLFwE/GHh+S79sVElOSLIyycoNGzZMcYmStPXadro2nORS4NGjvHRyVa3o25wM3AN8eLRNjLKsxtpfVZ0JnAmwbNmyMdtJkrbMtAVFVR3aej3J8cCRwCFVNdqB/RZgz4HnewDrpq5CSdJ4DOuqp8OA1wHPr6pfjNHsa8ATkjw2yfbAi4FPz1SNkqTOsM5RnA7sBFySZFWS9wAk2T3JhQD9ye5XAJ8H1gAfq6rrhlSvJG21pm3qqaWqHj/G8nXA4QPPLwQunKm6JEkPNBuuepIkzWIGhSSpyaCQJDUZFJKkJoNCktRkUEiSmgwKSVKTQSFJajIoJElNBoUkqcmgkCQ1GRSSpCaDQpLUZFBIkpoMCklSk0EhSWoyKCRJTQaFJKnJoJAkNRkUkqQmg0KS1GRQSJKaDApJUpNBIUlqMigkSU0GhSSpyaCQJDUZFJKkJoNCktRkUEiSmgwKSVKTQSFJajIoJElNBoUkqWkoQZHkbUmuT/KtJOcl2XmUNnsm+WKSNUmuS/LKIZQqSVu9YY0oLgH2rqonA98GThqlzT3Aq6vqScD+wMuTLJ3BGiVJwLbD2GlVXTzw9CvA0aO0WQ+s7x/fkWQNsAhYPSNFaqu0ev1GjjnjymGXsVVavX4jSxcumPQ25urvbyr6P12GEhQj/AlwbqtBkiXAU4GrGm1OAE4AWLx48RSWp63F8n0WDbuErdrShQsm9TuY67+/yfZ/OqWqpmfDyaXAo0d56eSqWtG3ORlYBhxVYxSSZEfgcuC0qvrUePa9bNmyWrly5cQKl6StUJKrq2rZaK9N24iiqg5tvZ7keOBI4JBGSGwHfBL48HhDQpI0tYYy9ZTkMOB1wEFV9Ysx2gR4H7Cmqt4+k/VJku43rKueTgd2Ai5JsirJewCS7J7kwr7NgcBLgWf3bVYlOXxI9UrSVmtYVz09fozl64DD+8f/CmQm65IkPZDvzJYkNRkUkqQmg0KS1GRQSJKapu0Nd8OUZANw0wRX3xW4bQrLmQ3mY59gfvbLPs0d861fj6mq3UZ7YV4GxWQkWTnWuxPnqvnYJ5if/bJPc8d87ddonHqSJDUZFJKkJoPigc4cdgHTYD72CeZnv+zT3DFf+/UAnqOQJDU5opAkNRkUkqQmg6KX5LAkNyT5bpLXD7ueiUry/iS3Jrl2YNkjk1yS5Dv990cMs8YtlWTPJF9MsibJdUle2S+fs/1KskOSryb5Zt+nN/XL52yfNkmyTZJvJLmgfz4f+nRjkmv6u1iv7JfN+X6Nl0FB9w8b+AfgucBS4CVJlg63qgn7AHDYiGWvB75QVU8AvtA/n0vuAV5dVU8C9gde3v9+5nK/fg08u6qeAuwDHJZkf+Z2nzZ5JbBm4Pl86BPAs6pqn4H3TsyXfm2WQdF5BvDdqvpeVd0FfBRYPuSaJqSqrgB+MmLxcuCD/eMPAv95JmuarKpaX1Vf7x/fQXcQWsQc7ld17uyfbtd/FXO4TwBJ9gCOAN47sHhO96lhvvbrAQyKziLgBwPPb+mXzRf/oarWQ3fQBR415HomLMkS4KnAVczxfvVTNKuAW4FLqmrO9wl4B/Ba4N6BZXO9T9CF+MVJrk5yQr9sPvRrXIbywUWz0GgfkOR1w7NMkh3pPkP9VVW1sfu03Lmrqn4D7JNkZ+C8JHsPuaRJSXIkcGtVXZ3k4CGXM9UOrKp1SR5F98mc1w+7oJnkiKJzC7DnwPM9gHVDqmU6/CjJQoD++61DrmeLJdmOLiQ+XFWf6hfP+X4BVNXtwGV055bmcp8OBJ6f5Ea66dtnJzmbud0n4L5P36SqbgXOo5uunvP9Gi+DovM14AlJHptke+DFwKeHXNNU+jRwfP/4eGDFEGvZYumGDu8D1lTV2wdemrP9SrJbP5IgyUOAQ4HrmcN9qqqTqmqPqlpC93/oX6rqOOZwnwCSPCzJTpseA88BrmWO92tL+M7sXpLD6eZXtwHeX1WnDbeiiUnyEeBgulsg/wg4BTgf+BiwGLgZeFFVjTzhPWsl+X3gS8A13D/3/Qa68xRzsl9Jnkx3AnQbuj/YPlZVf51kF+Zonwb1U0+vqaoj53qfkjyObhQB3XT9OVV12lzv15YwKCRJTU49SZKaDApJUpNBIUlqMigkSU0GhSSpyaCQJiHJLv0dRVcl+WGStf3jO5P847Drk6aCl8dKUyTJqcCdVfX3w65FmkqOKKRpkOTggc9jODXJB5Nc3H+uwVFJ/q7/fIOL+tuTkGTfJJf3N577/KbbQ0jDZlBIM+M/0t1+ezlwNvDFqvo94JfAEX1YvBs4uqr2Bd4PzMm7A2j+8e6x0sz4XFXdneQautt2XNQvvwZYAjwR2JvuzqT0bdYPoU7pAQwKaWb8GqCq7k1yd91/cvBeuv+HAa6rqgOGVaA0FqeepNnhBmC3JAdAd1v1JHsNuSYJMCikWaH/CN6jgbcm+SawCnjmUIuSel4eK0lqckQhSWoyKCRJTQaFJKnJoJAkNRkUkqQmg0KS1GRQSJKa/j+VNAN9ArESzAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# random.seed(0)\n",
    "# np.random.seed(0)\n",
    "# torch.manual_seed(0)\n",
    "\n",
    "lr = 0.00003\n",
    "num_episodes = 6000\n",
    "hidden_dim = 128\n",
    "# gamma = .95\n",
    "gamma = .95\n",
    "epsilon = 0.02\n",
    "target_update = 100\n",
    "# buffer_size = 100000\n",
    "buffer_size = 20000\n",
    "minimal_size = 1000\n",
    "batch_size = 900 #72\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "\n",
    "\n",
    "env = quantum_gate()\n",
    "\n",
    "state_dim = np.shape(env.state)[0]\n",
    "action_dim = 13  # 将连续动作分成13个离散动作\n",
    "\n",
    "\n",
    "\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon, target_update, device, \"DuelingDQN\")\n",
    "\n",
    "\n",
    "return_list, max_q_value_list, fidelity_list, evaluate_fidelity, evaluate_average_fidelity = train_DQN(agent, env, num_episodes, buffer_size, minimal_size, batch_size)\n",
    "\n",
    "\n",
    "frames_list = list(range(len(max_q_value_list)))\n",
    "plt.plot(frames_list, max_q_value_list)\n",
    "plt.xlabel('Frames')\n",
    "plt.ylabel('Max Q value')\n",
    "plt.title('DDDQN on two-qubit gate')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(return_list)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Inverse of logarithm of infidelity ')\n",
    "plt.title('DDDQN on two-qubit gate')\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(fidelity_list)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy with epsilon greedy ')\n",
    "plt.title('DDDQN on two-qubit gate')\n",
    "\n",
    "\n",
    "print(\"last epoch fidelity = \", fidelity_list[-1])\n",
    "\n",
    "\n",
    "action_list, debug_list = evaluate_DQN(agent, env)\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.plot(np.arange(len(env.fidelity)) * env.dt, env.fidelity)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Real time fidelity')\n",
    "plt.title('DDDQN on two-qubit gate')\n",
    "\n",
    "\n",
    "plt.figure()\n",
    "plt.step(np.arange(len(action_list)) * env.dt, action_list)\n",
    "plt.xlabel('Time')\n",
    "plt.ylabel('Delta')\n",
    "plt.title('DDDQN on two-qubit gate')\n",
    "print(\"final agent output fidelity = \", env.reward()[1])\n",
    "\n",
    "evaluate_fidelity = np.array(evaluate_fidelity)\n",
    "plt.figure()\n",
    "plt.plot(evaluate_average_fidelity)\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity of policy without epsilon greedy')\n",
    "plt.title('DDDQN on  two-qubit gate')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b418b155",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fidelity =  0.9973082622881014\n",
      "[[ 1.00000000e+00+0.00000000e+00j  0.00000000e+00+0.00000000e+00j\n",
      "   0.00000000e+00+0.00000000e+00j  0.00000000e+00+0.00000000e+00j\n",
      "   0.00000000e+00+0.00000000e+00j  0.00000000e+00+0.00000000e+00j]\n",
      " [ 0.00000000e+00+0.00000000e+00j  9.82453383e-01-1.84095062e-01j\n",
      "  -2.64509212e-02-1.39537271e-02j  0.00000000e+00+0.00000000e+00j\n",
      "   0.00000000e+00+0.00000000e+00j  0.00000000e+00+0.00000000e+00j]\n",
      " [ 0.00000000e+00+0.00000000e+00j  2.91756591e-02+6.56800181e-03j\n",
      "   6.27503235e-01+7.78039416e-01j  0.00000000e+00+0.00000000e+00j\n",
      "   0.00000000e+00+0.00000000e+00j  0.00000000e+00+0.00000000e+00j]\n",
      " [ 0.00000000e+00+0.00000000e+00j  0.00000000e+00+0.00000000e+00j\n",
      "   0.00000000e+00+0.00000000e+00j -7.10870629e-01-6.97775196e-01j\n",
      "  -3.46750247e-02+5.08772409e-02j -3.10920294e-02-5.49104679e-02j]\n",
      " [ 0.00000000e+00+0.00000000e+00j  0.00000000e+00+0.00000000e+00j\n",
      "   0.00000000e+00+0.00000000e+00j  5.47910030e-03+6.10450274e-02j\n",
      "  -9.62369665e-01+2.64663527e-01j -2.51896520e-04+6.42384655e-03j]\n",
      " [ 0.00000000e+00+0.00000000e+00j  0.00000000e+00+0.00000000e+00j\n",
      "   0.00000000e+00+0.00000000e+00j -1.48478131e-02-6.16096688e-02j\n",
      "   2.64208706e-03-1.16491413e-04j -4.19536385e-02+9.97104152e-01j]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9973082622881014"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x864 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_sequence(action_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "587119ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VAnet(\n",
       "  (fc1): Linear(in_features=97, out_features=1200, bias=True)\n",
       "  (fc_A): Linear(in_features=1200, out_features=13, bias=True)\n",
       "  (fc_V): Linear(in_features=1200, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agent.q_net"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d11f18a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
